'use strict';
 // 引入
 const fs = require('fs');
 const path = require('path');
const Controller = require('egg').Controller;

class FileController extends Controller {
  // 上传
  async upload() {
    //  结构数据
    let {app ,ctx,service}=this
    // 获取当前用户
    let currentUser=ctx.authUser
    // 参数验证
    ctx.validate({
        file_id:{
            type:'int',
            required:true,
            defValue:0,
            desc:'file_id'
        }
    })
    // 文件id是否存在
    const file_id=ctx.query.file_id
    if(file_id>0){
        // 目录是否存在
        await service.file.isDirExist(file_id)
    }
    // 验证用户剩余内存是否满足
    // const file = ctx.request.files;
    const file = ctx.request.files[0];
    const name = 'disk-cloud/' + ctx.genID(10) + path.extname(file.filename);
    let s = await (new Promise((resolve, reject) => {
        fs.stat(file.filepath, (err, stats) => {
            resolve((stats.size / 1024).toFixed(1));
        });
    }));
    console.log('----------------------------------')
    console.log(s)
    if(currentUser.total_size-currentUser.used_size<s){
        return ctx.apiFail("你的内存不足")
    }
    // 上传文件
    let result;
        try {
            result = await ctx.oss.put(name, file.filepath);
        } catch (err) {
            console.log(err);
        }
    // 判断上传结果
    if(!result){
        return ctx.apiFail("上传失败")
    }
    // 写入数据表
    let addData = {
        name: file.filename,
        ext: file.mimeType,
        md: result.name,
        file_id,
        user_id: currentUser.id,
        size: parseInt(s),
        isdir: 0,
        url: result.url
    };
    if (file_id > 0) {
        addData.file_id = file_id;
    }
    let res=await app.model.File.create(addData)
    // g更新user表的网盘容量
    currentUser.used_size=currentUser.used_size+parseInt(s)
    currentUser.save()
    return ctx.apiSuccess(res)
    // 返回
  }

//   文件列表
async list(){
    // 结构
    const {app ,ctx}=this
    // 获取当前用户id
    let user_id=ctx.authUser.id
    // 参数验证
    ctx.validate({
        file_id: {
            required: false,
            type: "int",
            defValue: 0,
            desc: "目录id"
        },
        orderby: {
            required: false,
            type: "string",
            defValue: 'name',
            range: {
                in: ['name', 'created_time']
            },
            desc: "排序"
        },
        type:{
            required: false,
            type: "string",
            desc: "类型"
        },
        isdir:{
            required:false,
            type:'int',
            defValue:2,
            range:{
                in:[0,1,2]
            },
            desc:'目录id'
        }
    })
    // 组织查询条件
    let {file_id,orderby,type,isdir}=ctx.query;
    let where={
       user_id
    }
    // 模糊搜索
    if(type && type !== 'all'){
        const Op = app.Sequelize.Op;
        where.ext = {
            [Op.like]: type + '%',  
        }
    }else{
        where.file_id=file_id
    }
    if(isdir!=2){
        where.isdir=isdir
    }

    // 查询
    let rows= await app.model.File.findAll({
        where,
        order:[
            ['isdir','desc'],
            [orderby,'desc']
        ]
    })
    // 返回数据
    ctx.apiSuccess(rows)
}


// 创建文件夹

async createDir(){
    // 结构数据
    let {app,ctx,service}=this
    let user_id=ctx.authUser.id
    // 参数验证
    ctx.validate({
        file_id:{
            required:true,
            defValue:0,
            type:'int',
            desc:'目录id'
        },
        name:{
            type:'string',
            required:true,
            desc:'文件名'
        }
    })
    let {file_id,name}=ctx.request.body
    // 判断文件是否存在
    if(file_id){
       await service.file.isDirExist(file_id)
    }
    // 创建文件 size:0
    let file=await app.model.File.create({
        name,
        file_id,
        user_id,
        isdir:1,
        size:0
    })
    // 返回数据
    ctx.apiSuccess(file)
}
// 重命名
async rename(){
    // 结构
    let {ctx,app,service}=this
    let user_id=ctx.authUser.id
    // 参数验证+获取请求参数
    ctx.validate({
        id:{
            type:'int',
           required:true,
           desc:'记录'
        },
        file_id:{
            type:'int',
            required:true,
            defValue:0,
            desc:'目录id'
        },
        name:{
            type:'string',
            required:true,
            desc:'文件名称'
        }
    })
    let {id,file_id,name}=ctx.request.body
    // 验证目录是否存在
    if(file_id>0){
        await service.file.isDirExist(file_id)
    }
    // 验证文件是否存在
    let f=await service.file.isExist(id)
    // 重命名
    f.name=name
    let res=await f.save()
    // 返回数据
    ctx.apiSuccess(res)
}

// 批量删除文件
async delete(){
    // 结构
    let {app,ctx}=this
    let user_id=ctx.authUser.id
    // 参数验证+获取请求参数
    ctx.validate({
        ids:{
            type:'string',
            required:true,
            desc:'记录'
        }
    })
    let {ids}=ctx.request.body
    ids=ids.split(',')
    // 计算删除的容量
    let files=await app.model.File.findAll({
        where:{
            id:ids,
            user_id
        }
    })
    let size=0
    files.forEach(item => {
        if(item){
            size+=item.size
        }
    });
    // 删除文件
    let res=await app.model.File.destroy({
        where:{
            id:ids,
            user_id
        }
    })
    // 计算用户容量
    if(res){
        size=ctx.authUser.size-size
        ctx.authUser.used_size=size>0?size:0
        ctx.authUser.save()
    }
    // 返回数据
    ctx.apiSuccess(res)

}

// 搜索文件
async search(){
    // 结构
    let {app,ctx}=this
    let user_id=ctx.authUser.id
    // 参数验证+获取请求参数
    ctx.validate({
        keyword:{
            type:'string',
            required:true,
            desc:'关键字'
        }
    })
    let {keyword}=ctx.query
    // 匹配
    const Op=app.Sequelize.Op
    // 查询
    let rows=await app.model.File.findAll({
        where:{
            name:{
                [Op.like]:`%${keyword}%`
            },
            user_id
        }
    })
    // 返回
    ctx.apiSuccess(rows)

}



}

module.exports = FileController;
